import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: DELL
 * Date: 2023-03-14
 * Time: 9:43
 */


public class Training_0313 {

    public boolean fun(String a) {
        return a.toLowerCase() == "admin";
    }

    public static void main2(String[] args) {
        Training_0313 training_0313 = new Training_0313();
        System.out.println(training_0313.fun("Admin"));
        String s = "a i";
        String[] x = s.split(" ");
    }

    /**
     * i like beijing. 实现逆置 为 beijing. like i
     */
    public void reserve() {
        Scanner scan = new Scanner(System.in);
        String str1 = scan.nextLine();
        // 1. 切分字符串
        String[] str2 = str1.split(" ");
        // 2. 存进栈中, 利用先进后出的特点实现逆置
        Stack<String> stack = new Stack<>();
        for (int i = 0; i < str2.length; i++) {
            stack.add(str2[i]);
        }
        // 3. 从栈顶依次弹出
        while (!stack.isEmpty()) {
            // 每次弹出拼接空格
            StringBuilder sb = new StringBuilder();
            System.out.print(stack.pop() + sb.append(" "));
        }
    }

    /**
     * 牛牛的子序列 - 一个序列中寻找递增或递减序列的子序列有几个
     */
    public void strChar() {
        Scanner scan = new Scanner(System.in);
        while (scan.hasNext()) {
            int n = scan.nextInt();
            int[] arr = new int[n + 1]; // 后续使用的是 i 和 i+1 比较 此处需要防止
            for (int i = 0; i < n; i++) {
                arr[i] = scan.nextInt();
            }
            int count = 0;
            int i = 0;
            while (i < n) {
                // 先判断头是递增还是递减
                // 1. 递增序列
                if (arr[i] < arr[i + 1]) {
                    // 寻找到递减情况
                    while (i < n && arr[i] < arr[i + 1]) {
                        i++;
                    }
                    count++;

                } else if (arr[i] > arr[i + 1]) {
                    // 2. 递减
                    // 寻找到递增情况
                    while (i < n && arr[i] > arr[i + 1]) {
                        i++;
                    }
                    count++;
                }
                // 相等情况下, 继续向后走, 无论是在递增还是递减序列中
                i++;
            }
            System.out.println(count);
        }
    }

    /**
     * @param words 单词数组
     * @return 返回 最终什么排序形式
     */
    public static String SortWord(String[] words) {
        boolean isDictionary = isDic(words);
        boolean isLength = isLen(words);
        if (isDictionary && isLength) {
            return "both";
        }
        if (isDictionary) {
            return "lexicographically";
        } else if (isLength) {
            return "lengths";
        } else {
            return "none";
        }
    }

    // 判断是否为字典序
    public static boolean isDic(String[] words) {
        boolean result = true;
        for (int i = 1; i < words.length; i++) {
            if (words[i].compareTo(words[i - 1]) <= 0) {
                // 返回 > 0 的值, 表明前面的单词比后面的单词排序大
                // 返回 < 0 的值, 表明前面的单词比后面的单词排序小
                // 返回 = 0 的值, 表明前面的单词和后面的单词相等
                result = false; // 非字典序
                break;
            }
        }
        return result;
    }

    // 判断是否为长度排序
    public static boolean isLen(String[] words) {
        boolean result = true;
        for (int i = 1; i < words.length; i++) {
            if (words[i].length() <= words[i - 1].length()) {
                result = false; // 非长度排序
                break;
            }
        }
        return result;
    }

    /**
     * 最小公倍数求解
     */
    public static void LCM() {
        Scanner scan = new Scanner(System.in);
        int a = scan.nextInt();
        int b = scan.nextInt();
        int max = a > b ? a : b; // 求的 a b 最大数
        for (int i = max; i <= a * b; i++) {
            if (max % a == 0 && max % b == 0) {
                System.out.println(max);
                break;
            }
            max++;
        }
    }

    /**
     * 将 m 的二进制 从 j 到 i 位插入, 保证 n 的 j 到 i 为均为 0
     *
     * @param n 32 位整数
     * @param m 32 为整数
     * @param j 从 j 位开始
     * @param i 到 i 位结束
     * @return
     */
    public int binInsert(int n, int m, int j, int i) {
        // write code here
        // 1024 100 0000 0000
        //
        // 19         10 011
        // m 左移 j 为
        //      100 1100 0000 m
        //      100 0000 0000 n
        //m | n 100 1100 0000
        m <<= j; // 对齐
        return m | n; // 有 1 则为1 全0 为 0;
    }

    /**
     * @param n 输入一个 偶数, 寻找这个偶数最接近的两个素数
     */
    public void doublePrime(int n) {
        for (int i = 0; i < n / 2; i++) {
            if (primeNumber((n / 2) - i) && primeNumber((n / 2) + i)) {
                System.out.println((n / 2) - i);
                System.out.println((n / 2) + i);
                break;
            }
        }
    }

    /**
     * 判断一个数是否为 素数
     *
     * @param n
     * @return 返回是否素数
     */
    private static boolean primeNumber(int n) {
        for (int i = 3; i < n; i++) {
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }

    public static void main1(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        String[] array = new String[n];
        // 多组输入
        while (scan.hasNextLine()) {
            for (int i = 0; i < n; i++) {
                array[i] = scan.next();
            }
            System.out.println(SortWord(array));
        }
        scan.close(); // 关闭输入资源
        byte b1 = 1, b2 = 2, b3, b6;
        final byte b4 = 4, b5 = 6;
        b3 = b4 + b5;
        //b3=(b1+b2);
    }

    /**
     * 参数解析
     * @param str 给定一串字符串, 解析一共有几个参数, 双引号之间算一个, 空格之间的内容算一个
     */
    public void parameter(String str) {
        int len = str.length();
        int end = 0;
        int start = 0; // 双指针遍历
        Queue<String> queue = new LinkedList<>(); // 存储参数字符串
        while (end < len) {
            // " 双引号不会出现在第一个字符串 "
            // 只会出现在中间, 因此在上一个空格结束后, 遇到第一个双引号
            if (str.charAt(end + 1) == '\"') {
                end = end + 2; // 当前 end 指向第二个空格处, 下一个位置为第一个单引号 "
                start = end;

                // 向后寻找下一个 "
                while (end < len && str.charAt(end) != '\"') {
                    end++;
                }
                // 此时 end 正好指向当前 "
                queue.offer(str.substring(start, end)); // 将" 引号中间的字符串加入 "
                end++; // 指向下一个
                continue; // 继续下一轮
            }
            // 寻找第一个空格
            while (end < len && str.charAt(end) == ' ') {
                end++;
            }
            start = end;

            // 寻找下一个空格
            while (end < len && str.charAt(end) != ' ') {
                end++;
            }
            // 添加进入
            queue.offer(str.substring(start, end));
        }
        System.out.println(queue.size());
        while (!queue.isEmpty()) {
            System.out.println(queue.poll());
        }
    }

    public static void main(String[] args) {
        int arr[] = new int[19];
        System.out.println(arr[19]);
    }
}
